package com.springboot_shopping.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.springboot_shopping.Mapper.CartItemMapper;
import com.springboot_shopping.Mapper.ProductMapper;
import com.springboot_shopping.entity.CartItem;
import com.springboot_shopping.entity.Product;
import com.springboot_shopping.service.CartService;
import com.springboot_shopping.vo.CartItemVo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class CartServiceImpl implements CartService {

    @Autowired
    private CartItemMapper cartItemMapper;

    @Autowired
    private ProductMapper productMapper;

    //添加商品到购物车
    @Override
    @Transactional
    public void addToCart(CartItem cartItem) {
        //设置创建时间和更新时间
        Timestamp now = Timestamp.valueOf(LocalDateTime.now());
        cartItem.setCreateTime(now);
        cartItem.setUpdateTime(now);

        //检查商品是否存在
        Product product = productMapper.selectById(cartItem.getProductId());
        if (product == null) {
            throw new RuntimeException("商品不存在");
        }


        //查询是否已存在购物车项
        QueryWrapper<CartItem> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", cartItem.getUserId())
                .eq("product_id", cartItem.getProductId());

        CartItem existing = cartItemMapper.selectOne(queryWrapper);

        if (existing != null) {
            //更新购物车中的商品数量
            int newQuantity = existing.getQuantity() + cartItem.getQuantity();
            existing.setQuantity(newQuantity);
            existing.setUpdateTime(now);
            cartItemMapper.updateById(existing);
        } else {
            //新增记录
            cartItemMapper.insert(cartItem);
        }

        // 扣减库存 - 使用数据库原子操作保证并发安全
        int affectedRows = productMapper.updateStock(cartItem.getProductId(), cartItem.getQuantity());
        if (affectedRows == 0) {
            throw new RuntimeException("库存不足，添加购物车失败");
        }
    }



    //更新购物车数量
    @Override
    @Transactional
    public void updateCartItemQuantity(Integer cartItemId, Integer quantity) {
        if (quantity <= 0) {
            throw new IllegalArgumentException("数量必须大于0");
        }

        CartItem cartItem = cartItemMapper.selectById(cartItemId);
        if (cartItem == null) {
            throw new RuntimeException("购物车项不存在");
        }

        //获取购物车中原来的商品数量
        int originalQuantity = cartItem.getQuantity();
        //更改的商品数量-原始的商品数量
        int delta = quantity - originalQuantity;

        //更改前后数量一致，则不用做任何操作
        if (delta == 0) {
            return;
        }

        //如果前后数量有变化的话，更新数量
        cartItem.setQuantity(quantity);
        cartItemMapper.updateById(cartItem);

        /*todo:逻辑思路：
          默认库存为9
        第一种情况：更新购买数量=5，原始=3，5-3=2，那么2>0，调用方法，库存数-2=9-2=7  -》购买量增多，那么库存减少
        *   第二种情况：更新购买量=3，原始=5，3-5=-2，那么-2<0，调用方法，库存数+2=9+2=11  -》更新的购买量减少，那么库存就要增多
        * */
        // 库存调整，如果购买数量增加的话，即delta > 0，则减少库存
        //第一种情况，更新的购买数量>原始数量，商品库存数减少
        if (delta > 0) {
            // 增加数量，减少库存
            int affectedRows = productMapper.updateStock(cartItem.getProductId(), delta);
            //特殊情况：库存<差值时，即更新的购买数量>库存数量，抛异常
            if (affectedRows == 0) {
                throw new RuntimeException("库存不足，更新失败");
            }
            //第二种情况:差值<0，即更新数量<原始数量，商品库存数增加
        } else {
            // 减少数量，恢复库存
            productMapper.updateStock(cartItem.getProductId(),delta);
        }
    }

    //更新购物车项选中状态
    @Override
    @Transactional
    public void updateSelectedStatus(Integer cartItemId, Boolean selected) {
        CartItem cartItem = cartItemMapper.selectById(cartItemId);
        if (cartItem == null) {
            throw new RuntimeException("购物车项不存在");
        }

        //更新选中状态
        cartItem.setSelected(selected);
        cartItemMapper.updateById(cartItem);
    }

    //删除购物车项
    @Override
    @Transactional
    public void removeCartItem(Integer cartItemId) {
        CartItem cartItem = cartItemMapper.selectById(cartItemId);
        if (cartItem == null) {
            throw new RuntimeException("购物车项不存在");
        }

        // 删除购物车项
        cartItemMapper.deleteById(cartItemId);
    }

    //获取购物车项，前端调用，用来展示购物车列表
    @Override
    public List<CartItemVo> getCartItems(Integer userId) {
        //查询用户所有购物车项
        QueryWrapper<CartItem> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        List<CartItem> cartItems = cartItemMapper.selectList(queryWrapper);

        //转换为VO对象
        return cartItems.stream().map(item -> {
            CartItemVo vo = new CartItemVo();
            //属性复制
            BeanUtils.copyProperties(item, vo);

            //获取商品信息
            Product product = productMapper.selectById(item.getProductId());
            if (product != null) {
                vo.setProductTitle(product.getTitle());
                vo.setProductPrice(product.getPrice());
                vo.setProductStock(product.getStock());
            }
            return vo;
        }).collect(Collectors.toList());
    }

    //清空购物车
    @Override
    @Transactional
    public void clearCart(Integer userId) {
        //清空用户购物车
        QueryWrapper<CartItem> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", userId);
        cartItemMapper.delete(queryWrapper);
    }
}